/**
 * 数据格式化工具
 * 提供各种数据格式化功能
 */

/**
 * 格式化日期时间
 * @param {Date|string|number} date - 日期对象、时间戳或日期字符串
 * @param {string} format - 格式化模板，默认 'YYYY-MM-DD HH:mm:ss'
 * @returns {string} 格式化后的日期字符串
 */
export const formatDateTime = (date, format = 'YYYY-MM-DD HH:mm:ss') => {
  if (!date) return ''
  
  const d = new Date(date)
  if (isNaN(d.getTime())) return ''
  
  const year = d.getFullYear()
  const month = String(d.getMonth() + 1).padStart(2, '0')
  const day = String(d.getDate()).padStart(2, '0')
  const hours = String(d.getHours()).padStart(2, '0')
  const minutes = String(d.getMinutes()).padStart(2, '0')
  const seconds = String(d.getSeconds()).padStart(2, '0')
  
  return format
    .replace('YYYY', year)
    .replace('MM', month)
    .replace('DD', day)
    .replace('HH', hours)
    .replace('mm', minutes)
    .replace('ss', seconds)
}

/**
 * 格式化日期
 * @param {Date|string|number} date - 日期
 * @returns {string} 格式化后的日期字符串
 */
export const formatDate = (date) => {
  return formatDateTime(date, 'YYYY-MM-DD')
}

/**
 * 格式化时间
 * @param {Date|string|number} date - 日期
 * @returns {string} 格式化后的时间字符串
 */
export const formatTime = (date) => {
  return formatDateTime(date, 'HH:mm:ss')
}

/**
 * 格式化相对时间
 * @param {Date|string|number} date - 日期
 * @returns {string} 相对时间描述
 */
export const formatRelativeTime = (date) => {
  if (!date) return ''
  
  const d = new Date(date)
  const now = new Date()
  const diff = now.getTime() - d.getTime()
  
  const minute = 60 * 1000
  const hour = 60 * minute
  const day = 24 * hour
  const week = 7 * day
  const month = 30 * day
  const year = 365 * day
  
  if (diff < minute) {
    return '刚刚'
  } else if (diff < hour) {
    return Math.floor(diff / minute) + '分钟前'
  } else if (diff < day) {
    return Math.floor(diff / hour) + '小时前'
  } else if (diff < week) {
    return Math.floor(diff / day) + '天前'
  } else if (diff < month) {
    return Math.floor(diff / week) + '周前'
  } else if (diff < year) {
    return Math.floor(diff / month) + '个月前'
  } else {
    return Math.floor(diff / year) + '年前'
  }
}

/**
 * 格式化金额
 * @param {number|string} amount - 金额
 * @param {number} decimals - 小数位数，默认2位
 * @param {boolean} showSymbol - 是否显示货币符号，默认true
 * @returns {string} 格式化后的金额
 */
export const formatMoney = (amount, decimals = 2, showSymbol = true) => {
  if (amount === undefined || amount === null || amount === '') return '0.00'
  
  const num = Number(amount)
  if (isNaN(num)) return '0.00'
  
  const formatted = num.toFixed(decimals).replace(/\B(?=(\d{3})+(?!\d))/g, ',')
  return showSymbol ? `¥${formatted}` : formatted
}

/**
 * 格式化百分比
 * @param {number} value - 数值
 * @param {number} decimals - 小数位数，默认2位
 * @returns {string} 格式化后的百分比
 */
export const formatPercent = (value, decimals = 2) => {
  if (value === undefined || value === null || value === '') return '0.00%'
  
  const num = Number(value)
  if (isNaN(num)) return '0.00%'
  
  return (num * 100).toFixed(decimals) + '%'
}

/**
 * 格式化手机号
 * @param {string} phone - 手机号
 * @param {boolean} mask - 是否脱敏，默认false
 * @returns {string} 格式化后的手机号
 */
export const formatPhone = (phone, mask = false) => {
  if (!phone) return ''
  
  const phoneStr = String(phone).replace(/\D/g, '')
  if (phoneStr.length !== 11) return phone
  
  if (mask) {
    return phoneStr.replace(/(\d{3})\d{4}(\d{4})/, '$1****$2')
  }
  
  return phoneStr.replace(/(\d{3})(\d{4})(\d{4})/, '$1 $2 $3')
}

/**
 * 格式化身份证号
 * @param {string} idCard - 身份证号
 * @param {boolean} mask - 是否脱敏，默认true
 * @returns {string} 格式化后的身份证号
 */
export const formatIdCard = (idCard, mask = true) => {
  if (!idCard) return ''
  
  const idStr = String(idCard)
  if (mask) {
    if (idStr.length === 15) {
      return idStr.replace(/(\d{6})\d{6}(\d{3})/, '$1******$2')
    } else if (idStr.length === 18) {
      return idStr.replace(/(\d{6})\d{8}(\d{4})/, '$1********$2')
    }
  }
  
  return idStr
}

/**
 * 格式化银行卡号
 * @param {string} cardNo - 银行卡号
 * @param {boolean} mask - 是否脱敏，默认true
 * @returns {string} 格式化后的银行卡号
 */
export const formatBankCard = (cardNo, mask = true) => {
  if (!cardNo) return ''
  
  const cardStr = String(cardNo).replace(/\D/g, '')
  
  if (mask && cardStr.length >= 8) {
    const start = cardStr.substring(0, 4)
    const end = cardStr.substring(cardStr.length - 4)
    const middle = '*'.repeat(cardStr.length - 8)
    return `${start}${middle}${end}`.replace(/(.{4})/g, '$1 ').trim()
  }
  
  return cardStr.replace(/(.{4})/g, '$1 ').trim()
}

/**
 * 格式化文件大小
 * @param {number} size - 文件大小（字节）
 * @param {number} decimals - 小数位数，默认2位
 * @returns {string} 格式化后的文件大小
 */
export const formatFileSize = (size, decimals = 2) => {
  if (size === 0) return '0 B'
  
  const k = 1024
  const dm = decimals < 0 ? 0 : decimals
  const sizes = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
  
  const i = Math.floor(Math.log(size) / Math.log(k))
  
  return parseFloat((size / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i]
}

/**
 * 格式化数字
 * @param {number} num - 数字
 * @param {number} decimals - 小数位数，默认0位
 * @returns {string} 格式化后的数字
 */
export const formatNumber = (num, decimals = 0) => {
  if (num === undefined || num === null || num === '') return '0'
  
  const number = Number(num)
  if (isNaN(number)) return '0'
  
  return number.toFixed(decimals).replace(/\B(?=(\d{3})+(?!\d))/g, ',')
}

/**
 * 格式化地址
 * @param {object} address - 地址对象
 * @param {string} address.province - 省份
 * @param {string} address.city - 城市
 * @param {string} address.district - 区县
 * @param {string} address.detail - 详细地址
 * @returns {string} 格式化后的地址
 */
export const formatAddress = (address) => {
  if (!address) return ''
  
  const { province = '', city = '', district = '', detail = '' } = address
  
  let result = ''
  if (province) result += province
  if (city && city !== province) result += city
  if (district && district !== city) result += district
  if (detail) result += detail
  
  return result
}

/**
 * 格式化状态文本
 * @param {number|string} status - 状态值
 * @param {object} statusMap - 状态映射表
 * @param {string} defaultText - 默认文本
 * @returns {string} 状态文本
 */
export const formatStatus = (status, statusMap, defaultText = '未知') => {
  if (status === undefined || status === null) return defaultText
  return statusMap[status] || defaultText
}

/**
 * 格式化枚举值
 * @param {any} value - 枚举值
 * @param {Array} enumList - 枚举列表
 * @param {string} labelKey - 标签字段名，默认'label'
 * @param {string} valueKey - 值字段名，默认'value'
 * @param {string} defaultText - 默认文本
 * @returns {string} 枚举标签
 */
export const formatEnum = (value, enumList, labelKey = 'label', valueKey = 'value', defaultText = '未知') => {
  if (!enumList || !Array.isArray(enumList)) return defaultText
  
  const item = enumList.find(item => item[valueKey] === value)
  return item ? item[labelKey] : defaultText
}